// Auto-generated, do not edit.

extern "C" {

curandStatus_t CURANDAPI curandCreateGenerator(curandGenerator_t *generator,
                                               curandRngType_t rng_type) {
  using FuncPtr =
      curandStatus_t(CURANDAPI *)(curandGenerator_t *, curandRngType_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandCreateGenerator");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(generator, rng_type);
}

curandStatus_t CURANDAPI curandCreateGeneratorHost(curandGenerator_t *generator,
                                                   curandRngType_t rng_type) {
  using FuncPtr =
      curandStatus_t(CURANDAPI *)(curandGenerator_t *, curandRngType_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandCreateGeneratorHost");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(generator, rng_type);
}

curandStatus_t CURANDAPI curandDestroyGenerator(curandGenerator_t generator) {
  using FuncPtr = curandStatus_t(CURANDAPI *)(curandGenerator_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandDestroyGenerator");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(generator);
}

curandStatus_t CURANDAPI curandGetVersion(int *version) {
  using FuncPtr = curandStatus_t(CURANDAPI *)(int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandGetVersion");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(version);
}

curandStatus_t CURANDAPI curandGetProperty(libraryPropertyType type,
                                           int *value) {
  using FuncPtr = curandStatus_t(CURANDAPI *)(libraryPropertyType, int *);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandGetProperty");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(type, value);
}

curandStatus_t CURANDAPI curandSetStream(curandGenerator_t generator,
                                         cudaStream_t stream) {
  using FuncPtr = curandStatus_t(CURANDAPI *)(curandGenerator_t, cudaStream_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandSetStream");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(generator, stream);
}

curandStatus_t CURANDAPI curandSetPseudoRandomGeneratorSeed(
    curandGenerator_t generator, unsigned long long seed) {
  using FuncPtr =
      curandStatus_t(CURANDAPI *)(curandGenerator_t, unsigned long long);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("curandSetPseudoRandomGeneratorSeed");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(generator, seed);
}

curandStatus_t CURANDAPI curandSetGeneratorOffset(curandGenerator_t generator,
                                                  unsigned long long offset) {
  using FuncPtr =
      curandStatus_t(CURANDAPI *)(curandGenerator_t, unsigned long long);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandSetGeneratorOffset");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(generator, offset);
}

curandStatus_t CURANDAPI curandSetGeneratorOrdering(curandGenerator_t generator,
                                                    curandOrdering_t order) {
  using FuncPtr =
      curandStatus_t(CURANDAPI *)(curandGenerator_t, curandOrdering_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandSetGeneratorOrdering");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(generator, order);
}

curandStatus_t CURANDAPI curandSetQuasiRandomGeneratorDimensions(
    curandGenerator_t generator, unsigned int num_dimensions) {
  using FuncPtr = curandStatus_t(CURANDAPI *)(curandGenerator_t, unsigned int);
  static auto func_ptr =
      LoadSymbol<FuncPtr>("curandSetQuasiRandomGeneratorDimensions");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(generator, num_dimensions);
}

curandStatus_t CURANDAPI curandGenerate(curandGenerator_t generator,
                                        unsigned int *outputPtr, size_t num) {
  using FuncPtr =
      curandStatus_t(CURANDAPI *)(curandGenerator_t, unsigned int *, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandGenerate");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(generator, outputPtr, num);
}

curandStatus_t CURANDAPI curandGenerateLongLong(curandGenerator_t generator,
                                                unsigned long long *outputPtr,
                                                size_t num) {
  using FuncPtr = curandStatus_t(CURANDAPI *)(curandGenerator_t,
                                              unsigned long long *, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandGenerateLongLong");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(generator, outputPtr, num);
}

curandStatus_t CURANDAPI curandGenerateUniform(curandGenerator_t generator,
                                               float *outputPtr, size_t num) {
  using FuncPtr =
      curandStatus_t(CURANDAPI *)(curandGenerator_t, float *, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandGenerateUniform");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(generator, outputPtr, num);
}

curandStatus_t CURANDAPI curandGenerateUniformDouble(
    curandGenerator_t generator, double *outputPtr, size_t num) {
  using FuncPtr =
      curandStatus_t(CURANDAPI *)(curandGenerator_t, double *, size_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandGenerateUniformDouble");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(generator, outputPtr, num);
}

curandStatus_t CURANDAPI curandGenerateNormal(curandGenerator_t generator,
                                              float *outputPtr, size_t n,
                                              float mean, float stddev) {
  using FuncPtr = curandStatus_t(CURANDAPI *)(curandGenerator_t, float *,
                                              size_t, float, float);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandGenerateNormal");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(generator, outputPtr, n, mean, stddev);
}

curandStatus_t CURANDAPI curandGenerateNormalDouble(curandGenerator_t generator,
                                                    double *outputPtr, size_t n,
                                                    double mean,
                                                    double stddev) {
  using FuncPtr = curandStatus_t(CURANDAPI *)(curandGenerator_t, double *,
                                              size_t, double, double);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandGenerateNormalDouble");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(generator, outputPtr, n, mean, stddev);
}

curandStatus_t CURANDAPI curandGenerateLogNormal(curandGenerator_t generator,
                                                 float *outputPtr, size_t n,
                                                 float mean, float stddev) {
  using FuncPtr = curandStatus_t(CURANDAPI *)(curandGenerator_t, float *,
                                              size_t, float, float);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandGenerateLogNormal");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(generator, outputPtr, n, mean, stddev);
}

curandStatus_t CURANDAPI
curandGenerateLogNormalDouble(curandGenerator_t generator, double *outputPtr,
                              size_t n, double mean, double stddev) {
  using FuncPtr = curandStatus_t(CURANDAPI *)(curandGenerator_t, double *,
                                              size_t, double, double);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandGenerateLogNormalDouble");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(generator, outputPtr, n, mean, stddev);
}

curandStatus_t CURANDAPI curandCreatePoissonDistribution(
    double lambda, curandDiscreteDistribution_t *discrete_distribution) {
  using FuncPtr =
      curandStatus_t(CURANDAPI *)(double, curandDiscreteDistribution_t *);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandCreatePoissonDistribution");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(lambda, discrete_distribution);
}

curandStatus_t CURANDAPI
curandDestroyDistribution(curandDiscreteDistribution_t discrete_distribution) {
  using FuncPtr = curandStatus_t(CURANDAPI *)(curandDiscreteDistribution_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandDestroyDistribution");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(discrete_distribution);
}

curandStatus_t CURANDAPI curandGeneratePoisson(curandGenerator_t generator,
                                               unsigned int *outputPtr,
                                               size_t n, double lambda) {
  using FuncPtr = curandStatus_t(CURANDAPI *)(curandGenerator_t, unsigned int *,
                                              size_t, double);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandGeneratePoisson");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(generator, outputPtr, n, lambda);
}

curandStatus_t CURANDAPI curandGeneratePoissonMethod(
    curandGenerator_t generator, unsigned int *outputPtr, size_t n,
    double lambda, curandMethod_t method) {
  using FuncPtr = curandStatus_t(CURANDAPI *)(curandGenerator_t, unsigned int *,
                                              size_t, double, curandMethod_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandGeneratePoissonMethod");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(generator, outputPtr, n, lambda, method);
}

curandStatus_t CURANDAPI curandGenerateBinomial(curandGenerator_t generator,
                                                unsigned int *outputPtr,
                                                size_t num, unsigned int n,
                                                double p) {
  using FuncPtr = curandStatus_t(CURANDAPI *)(curandGenerator_t, unsigned int *,
                                              size_t, unsigned int, double);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandGenerateBinomial");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(generator, outputPtr, num, n, p);
}

curandStatus_t CURANDAPI curandGenerateBinomialMethod(
    curandGenerator_t generator, unsigned int *outputPtr, size_t num,
    unsigned int n, double p, curandMethod_t method) {
  using FuncPtr =
      curandStatus_t(CURANDAPI *)(curandGenerator_t, unsigned int *, size_t,
                                  unsigned int, double, curandMethod_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandGenerateBinomialMethod");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(generator, outputPtr, num, n, p, method);
}

curandStatus_t CURANDAPI curandGenerateSeeds(curandGenerator_t generator) {
  using FuncPtr = curandStatus_t(CURANDAPI *)(curandGenerator_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandGenerateSeeds");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(generator);
}

curandStatus_t CURANDAPI curandGetDirectionVectors32(
    curandDirectionVectors32_t *vectors[], curandDirectionVectorSet_t set) {
  using FuncPtr = curandStatus_t(CURANDAPI *)(curandDirectionVectors32_t *[],
                                              curandDirectionVectorSet_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandGetDirectionVectors32");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(vectors, set);
}

curandStatus_t CURANDAPI
curandGetScrambleConstants32(unsigned int **constants) {
  using FuncPtr = curandStatus_t(CURANDAPI *)(unsigned int **);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandGetScrambleConstants32");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(constants);
}

curandStatus_t CURANDAPI curandGetDirectionVectors64(
    curandDirectionVectors64_t *vectors[], curandDirectionVectorSet_t set) {
  using FuncPtr = curandStatus_t(CURANDAPI *)(curandDirectionVectors64_t *[],
                                              curandDirectionVectorSet_t);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandGetDirectionVectors64");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(vectors, set);
}

curandStatus_t CURANDAPI
curandGetScrambleConstants64(unsigned long long **constants) {
  using FuncPtr = curandStatus_t(CURANDAPI *)(unsigned long long **);
  static auto func_ptr = LoadSymbol<FuncPtr>("curandGetScrambleConstants64");
  if (!func_ptr) return GetSymbolNotFoundError();
  return func_ptr(constants);
}

}  // extern "C"
